package com.xiyuan.smartutils;

import java.io.FileNotFoundException;
import java.util.Collection;
import java.util.function.Supplier;


/**
 * 断言相关工具类
 *
 * @version v1.1.2 @author lgz 2017-10-4 新建与整理
 */

@SuppressWarnings({"DanglingJavadoc", "UnusedReturnValue"})
public final class Asserts {
    /*****************************************************************************/
    // 断言， 三目运算判断exception!=null时抛出IllegalArgumentException
    /*****************************************************************************/
    
    /**
     * 断言，三目运算判断，为exception=null时表示正常，否则抛出非法的参数异常
     *
     * @param exception 异常信息
     */
    public static void as(String exception) {
        if (exception == null) {return;}
        
        throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
    }
    
    /**
     * 断言，三目运算判断，为exception=null时表示正常，否则抛出非法的参数异常
     *
     * @param exception 异常信息
     * @param arguments 异常信息中的格式化参数表
     */
    public static void as(String exception, Object... arguments) {
        if (exception == null) {return;}
        
        exception = StrUtils.formatTwo(exception, arguments);
        throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
    }
    
    /**
     * 断言，传入要断言的判断，为false时抛出非法的状态异常
     *
     * @param exception 异常信息
     */
    public static void asState(String exception) {
        if (exception == null) {return;}
        
        throw new IllegalStateException(Threads.getInvokerAbbr() + exception);
    }
    
    /**
     * 断言，传入要断言的判断，为false时抛出非法的状态异常
     *
     * @param exception 异常信息
     * @param arguments 异常信息中的格式化参数表
     */
    public static void asState(String exception, Object... arguments) {
        if (exception == null) {return;}
        
        exception = StrUtils.formatTwo(exception, arguments);
        throw new IllegalStateException(Threads.getInvokerAbbr() + exception);
    }
    
    /**
     * 传入参数如果为 null 则抛出异常
     *
     * @param param 参数
     */
    public static void nonNull(Object param) {
        if (param == null) {
            throw new NullPointerException(Threads.getInvokerAbbr() + "参数不能为null");
        }
    }
    
    /**
     * 传入参数如果为 null 则抛出异常
     *
     * @param param     参数
     * @param paramName 字段名
     */
    public static void nonNull(Object param, String paramName) {
        if (param == null) {
            String exception = StrUtils.formatTwo("参数[%s]不能为null", paramName);
            throw new NullPointerException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 断言对象不为null，如果为null则抛出非法的参数异常
     *
     * @param param         参数
     * @param exception     异常信息
     * @param arguments     异常信息中的格式化参数表
     */
    public static void isNull(Object param, String exception, Object... arguments)
    {
        if (param == null){
            exception = StrUtils.formatTwo(exception, arguments);
            throw new NullPointerException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 传入参数如果为空则抛出非法的参数异常
     *
     * @param param 参数
     */
    public static void nonEmpty(String param) {
        if (Validates.isEmpty(param)) {
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + "参数不能为空");
        }
    }
    
    /**
     * 传入参数如果为空则抛出非法的参数异常
     *
     * @param param     参数
     * @param paramName 字段名
     */
    public static void nonEmpty(String param, String paramName) {
        if (Validates.isEmpty(param)) {
            String exception = StrUtils.formatTwo("参数[%s]不能为空", paramName);
            throw new NullPointerException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 传入参数如果为空则抛出非法的参数异常
     *
     * @param param 参数
     */
    public static void nonEmpty(Object param) {
        if (Validates.isEmpty(param)) {
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + "参数不能为空");
        }
    }
    
    /**
     * 传入参数如果为空则抛出非法的参数异常
     *
     * @param param     参数
     * @param paramName 字段名
     */
    public static void nonEmpty(Object param, String paramName) {
        if (Validates.isEmpty(param)) {
            String exception = StrUtils.formatTwo("参数[%s]不能为空", paramName);
            throw new NullPointerException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 传入参数如果为空白或者空则抛出非法的参数异常
     *
     * @param param 参数
     */
    public static void nonBlank(String param) {
        if (Validates.isBlank(param)) {
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + "参数不能为空");
        }
    }
    
    /**
     * 传入参数如果为空白或者空则抛出非法的参数异常
     *
     * @param param     参数
     * @param paramName 字段名
     */
    public static void nonBlank(String param, String paramName) {
        if (Validates.isBlank(param)) {
            String exception = StrUtils.formatTwo("参数[%s]不能为空", paramName);
            throw new NullPointerException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 断言字符串是整型，支持前缀+-，如果不是整型则抛出非法的参数异常
     *
     * @param param 参数
     */
    public static void isInteger(String param) {
        if (!Validates.isInteger(param)) {
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + "参数必须为整型");
        }
    }
    
    /**
     * 断言字符串是整型，支持前缀+-，如果不是整型则抛出非法的参数异常
     *
     * @param param     参数
     * @param paramName 字段名
     */
    public static void isInteger(String param, String paramName) {
        if (!Validates.isInteger(param)) {
            String exception = StrUtils.formatTwo("参数[%s]必须为整型", paramName);
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /*****************************************************************************/
    // 断言， 判断结果=false时抛出IllegalArgumentException
    /*****************************************************************************/
    
    /**
     * 断言是否为真，如果为 {@code false} 抛出给定的异常<br>
     *
     * <pre class="code">
     * Assert.isTrue(i &gt; 0, IllegalArgumentException::new);
     * </pre>
     *
     * @param <X>        异常类型
     * @param expression 布尔值
     * @param supplier   指定断言不通过时抛出的异常
     * @throws X if expression is {@code false}
     */
    public static <X extends Throwable> void as(boolean expression, Supplier<? extends X> supplier) throws X {
        if (!expression) {
            throw supplier.get();
        }
    }
    
    /**
     * 断言，传入要断言的判断，为true时抛出非法的参数异常
     *
     * @param param     断言为true时抛出非法的参数异常
     * @param exception 异常信息
     */
    public static void is(boolean param, String exception) {
        String abbr = Threads.getInvokerAbbr();
        as(!param, () -> new IllegalArgumentException(abbr + exception));
    }
    
    /**
     * 断言，传入要断言的判断，为false时抛出非法的参数异常
     *
     * @param param     断言为false时抛出非法的参数异常
     * @param exception 异常信息
     */
    public static void as(boolean param, String exception) {
        String abbr = Threads.getInvokerAbbr();
        as(param, () -> new IllegalArgumentException(abbr + exception));
    }
    
    /**
     * 断言，传入要断言的判断，为false时抛出非法的参数异常
     *
     * @param param     断言为false时抛出非法的参数异常
     * @param exception 异常信息
     * @param arguments 异常信息中的格式化参数表
     */
    public static void as(boolean param, String exception, Object... arguments) {
        String abbr = Threads.getInvokerAbbr();
        as(param, () -> new IllegalArgumentException(abbr + StrUtils.formatTwo(exception, arguments)));
    }
    
    
    /**
     * 传入参数如果为空则抛出非法的参数异常
     *
     * @param param     参数
     * @param exception 异常信息
     */
    public static void asEmpty(String param, String exception) {
        if (Validates.isEmpty(param)) {
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 传入参数如果为空则抛出非法的参数异常
     *
     * @param param     参数
     * @param exception 异常信息
     * @param arguments 异常信息中的格式化参数表
     */
    public static void asEmpty(String param, String exception, Object... arguments) {
        if (Validates.isEmpty(param)) {
            exception = StrUtils.formatTwo(exception, arguments);
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 传入参数如果为空则抛出非法的参数异常
     *
     * @param param     集合参数
     * @param exception 异常信息
     * @param arguments 异常信息中的格式化参数表
     */
    public static void asEmpty(Collection<?> param, String exception, Object... arguments) {
        if (Validates.isEmpty(param)) {
            exception = StrUtils.formatTwo(exception, arguments);
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 传入参数如果为空则抛出非法的参数异常
     *
     * @param param     数组参数
     * @param exception 异常信息
     * @param arguments 异常信息中的格式化参数表
     */
    public static void asEmpty(Object[] param, String exception, Object... arguments) {
        if (Validates.isEmpty(param)) {
            exception = StrUtils.formatTwo(exception, arguments);
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 断言字符串不为空白，如果为空白则抛出非法的参数异常
     *
     * @param param     参数
     * @param exception 异常信息
     */
    public static void asBlank(String param, String exception) {
        if (Validates.isBlank(param)) {
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 断言字符串不为空白，如果为空白则抛出非法的参数异常
     *
     * @param param     参数
     * @param exception 异常信息
     * @param arguments 异常信息中的格式化参数表
     */
    public static void asBlank(String param, String exception, Object... arguments) {
        if (Validates.isBlank(param)) {
            exception = StrUtils.formatTwo(exception, arguments);
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出自定义异常。
     * 并使用指定的函数获取错误信息返回
     * <pre class="code">
     * Assert.notBlank(name, ()-&gt;{
     *      // to query relation message
     *      return new IllegalArgumentException("relation message to return");
     *  });
     * </pre>
     *
     * @param <X>              异常类型
     * @param <T>              字符串类型
     * @param text             被检查字符串
     * @param errorMsgSupplier 错误抛出异常附带的消息生产接口
     * @return 非空字符串
     * @throws X 被检查字符串为空白
     * @see StrUtils#isNotBlank(CharSequence)
     */
    public static <T extends CharSequence, X extends Throwable> T notBlank(T text, Supplier<X> errorMsgSupplier) throws
                                                                                                                 X {
        if (StrUtils.isBlank(text)) {
            throw errorMsgSupplier.get();
        }
        return text;
    }
    
    /**
     * 检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出 {@link IllegalArgumentException}
     *
     * <pre class="code">
     * Assert.notBlank(name, "Name must not be blank");
     * </pre>
     *
     * @param <T>              字符串类型
     * @param text             被检查字符串
     * @param errorMsgTemplate 错误消息模板，变量使用{}表示
     * @param params           参数
     * @return 非空字符串
     * @throws IllegalArgumentException 被检查字符串为空白
     * @see StrUtils#isNotBlank(CharSequence)
     */
    public static <T extends CharSequence> T notBlank(T text, String errorMsgTemplate, Object... params) throws IllegalArgumentException {
        return notBlank(text, () -> new IllegalArgumentException(StrUtils.format(errorMsgTemplate, params)));
    }
    
    /**
     * 检查给定字符串是否为空白（null、空串或只包含空白符），为空抛出 {@link IllegalArgumentException}
     *
     * <pre class="code">
     * Assert.notBlank(name);
     * </pre>
     *
     * @param <T>  字符串类型
     * @param text 被检查字符串
     * @return 非空字符串
     * @throws IllegalArgumentException 被检查字符串为空白
     * @see StrUtils#isNotBlank(CharSequence)
     */
    public static <T extends CharSequence> T notBlank(T text) throws IllegalArgumentException {
        return notBlank(text, "[Assertion failed] - this String argument must have text; it must not be null, empty, or blank");
    }
    
    /**
     * 断言字符串是整型，支持前缀+-，如果不是整型则抛出非法的参数异常
     *
     * @param param     参数
     * @param exception 异常信息
     */
    public static void assetInteger(String param, String exception) {
        if (!Validates.isInteger(param)) {
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /**
     * 断言字符串是整型，支持前缀+-，如果不是整型则抛出非法的参数异常
     *
     * @param param     参数
     * @param exception 异常信息
     * @param arguments 异常信息中的格式化参数表
     */
    public static void isInteger(String param, String exception, Object... arguments) {
        if (!Validates.isInteger(param)) {
            exception = StrUtils.formatTwo(exception, arguments);
            throw new IllegalArgumentException(Threads.getInvokerAbbr() + exception);
        }
    }
    
    /*****************************************************************************/
    // 返回断言异常，IllegalArgumentException
    /*****************************************************************************/
    
    /**
     * 断言，直接抛出异常，信息会在原信息上加上类和方法名
     *
     * @param message 异常信息
     * @return IllegalArgumentException
     */
    public static IllegalArgumentException exception(String message) {
        return new IllegalArgumentException(Threads.getInvokerAbbr() + message);
    }
    
    
    /**
     * 断言，直接抛出异常，信息会在原信息上加上类和方法名
     *
     * @return IllegalArgumentException
     */
    public static IllegalArgumentException exception(Exception e) {
        return new IllegalArgumentException(Threads.getInvokerAbbr() + e.getMessage(), e);
    }
    
    /**
     * 断言，直接抛出异常，信息会在原信息上加上类和方法名
     *
     * @param message   异常信息
     * @param arguments 异常信息中的格式化参数表
     * @return IllegalArgumentException
     */
    public static IllegalArgumentException exception(String message, Object... arguments) {
        message = StrUtils.formatTwo(message, arguments);
        return new IllegalArgumentException(Threads.getInvokerAbbr() + message);
    }
    
    
    /**
     * 断言，直接抛出异常，信息会在原信息上加上类和方法名
     *
     * @param message 异常信息
     * @param e       异常类
     * @return IllegalArgumentException
     */
    public static IllegalArgumentException exception(String message, Exception e) {
        return new IllegalArgumentException(Threads.getInvokerAbbr() + message, e);
    }
    
    /**
     * 断言，直接抛出异常，信息会在原信息上加上类和方法名
     *
     * @param message   异常信息
     * @param e         异常类
     * @param arguments 异常信息中的格式化参数表
     * @return IllegalArgumentException
     */
    public static IllegalArgumentException exception(String message, Exception e, Object... arguments) {
        message = StrUtils.formatTwo(message, arguments);
        return new IllegalArgumentException(Threads.getInvokerAbbr() + message, e);
    }
    
    /**
     * 断言，直接抛出文件未找到异常
     *
     * @param message 异常信息
     * @return FileNotFoundException
     */
    public static FileNotFoundException notFound(String message) {
        return new FileNotFoundException(Threads.getInvokerAbbr() + message);
    }
    
    /**
     * 断言，直接抛出文件未找到异常
     *
     * @param message   异常信息
     * @param arguments 异常信息中的格式化参数表
     * @return FileNotFoundException
     */
    public static FileNotFoundException notFound(String message, Object... arguments) {
        message = StrUtils.formatTwo(message, arguments);
        return new FileNotFoundException(Threads.getInvokerAbbr() + message);
    }
}
